package controller

import (
	"hytx_manager/pkg/app"
	"github.com/gin-gonic/gin"
	"github.com/Unknwon/com"
	"hytx_manager/models"
	"time"
	"github.com/jinzhu/gorm"
	"strconv"
)

const (
	ONE_USER_PROPORTION        = 0.25 // 一级普通会员返佣比例
	TWO_USER_PROPORTION        = 0.15 // 二级普通会员返佣比例
	ONE_SALESMAN_PROPORTION    = 0.4  // 一级业务员返佣比例
	TWO_SALESMAN_PROPORTION    = 0.15 // 二级业务员返佣比例
	THREE_SALESMAN_PROPORTION  = 0.05 // 三级业务员返佣比例
	OPRATOR_PROPORTION         = 0.2  // 运营商返佣比例
	PLACE_PARTNER_PROPORTION   = 0.1  // 城市合伙人返佣比例
	OPERATORS_PARTNER          = 0.5  //城市合伙人授权运营商代理费
	ENTERPRISE_USER_PROPORTION = 0.05 //企业佣金比例
)

// 会员充值
func MemberRecharge(c *gin.Context) {
	appG := app.Gin{c}
	user_id := com.StrTo(c.PostForm("user_id")).MustInt()
	vip_id := com.StrTo(c.PostForm("vip_id")).MustInt()

	user := models.Users{
		ID: user_id,
	}
	userInfo, err := user.GetUserInfoById() // 用户信息
	if err != nil {
		appG.ResponseMsg(200, "用户信息错误！", "")
		return
	}

	vip := models.VipFeeConfig{
		ID: vip_id,
	}
	vipInfo, err := vip.GetVipFeeConfigInfoById()
	if err != nil {
		appG.ResponseMsg(200, "会员类型错误！", "")
		return
	}

	user_grade := models.UserGrade{
		ID: user_id,
	}
	user_grade_info, _ := user_grade.GetUserGradeInfoById() // 用户等级信息

	now := time.Now()

	db := models.DB.Begin() // 开启事物

	if user_grade_info == nil { // 如何会员没有等级信息
		user_grade_struct := models.UserGrade{
			UserId:         user_id,
			LastMoney:      vipInfo.Money,
			VipFeeConfigId: vipInfo.ID,
			CreatedAt:      time.Now(),
			UpdatedAt:      time.Now(),
			OveredAt:       now.Add(time.Duration(vipInfo.Days) * 24 * time.Hour), // 会员到期时间
			LastAt:         now.Add(time.Duration(vipInfo.Days+3) * 24 * time.Hour),
		}
		// 新增会员等级记录
		result := db.Table("user_grade").Create(&user_grade_struct)

		if result.Error != nil {
			appG.ResponseMsg(200, "用户等级信息添加错误！", "")
			return
		}
	} else {
		// 判断会员是否到期，如果没到期就不能修改
		if (user_grade_info.OveredAt.Unix()-now.Unix() > 0) {
			appG.ResponseMsg(200, "该会员还没过期！", "")
			return
		}
		// 修改会员等级记录
		result := db.Table("user_grade").Save(models.UserGrade{
			ID:             user_grade_info.ID,
			UserId:         user_id,
			LastMoney:      vipInfo.Money,
			VipFeeConfigId: vipInfo.ID,
			CreatedAt:      time.Now(),
			UpdatedAt:      time.Now(),
			OveredAt:       now.Add(time.Duration(vipInfo.Days) * 24 * time.Hour), // 会员到期时间
			LastAt:         now.Add(time.Duration(vipInfo.Days+3) * 24 * time.Hour),
		})

		if result.Error != nil {
			db.Rollback()
			appG.ResponseMsg(200, "用户等级信息修改错误！", "")
			return
		}
	}

	// 订单号
	OutTradeNo := strconv.FormatInt(time.Now().Unix()+int64(user_id), 10)

	// 记录充值表
	r := db.Table("user_recharges").Create(&models.UserRecharges{
		UserId:              user_id,
		Money:               vipInfo.Money,
		VipFeeConfigId:      vipInfo.ID,
		LastMoney:           vipInfo.Money,
		OveredAt:            now.Add(time.Duration(vipInfo.Days) * 24 * time.Hour), // 会员到期时间
		LastAt:              now.Add(time.Duration(vipInfo.Days+3) * 24 * time.Hour),
		VipFeeConfigComment: vipInfo.Name,
		IsPay:               1,
		PayTime:             time.Now(),
		PayType:             "平台充值",
		Appid:               "0",
		MchId:               "0",
		NonceStr:            "0",
		Sign:                "0",
		OutTradeNo:          OutTradeNo,
		WeixinTotalFee:      0,
		Status:              1,
		CreatedAt:           time.Now(),
		UpdatedAt:           time.Now(),
	})

	if r.Error != nil {
		db.Rollback()
		appG.ResponseMsg(200, "记录充值错误！", "")
		return
	}

	//分销提成
	e := distributionExtract(userInfo, db, vipInfo.Money, OutTradeNo)
	if e != "" {
		db.Rollback()
		appG.ResponseMsg(200, e, "")
		return
	}

	//// 账单明细表
	//rs := db.Table("user_wallet_record_log").Create(&models.UserWalletRecordLog{
	//	UserId:    userInfo.ID,
	//	Type:      8,
	//	IncomeType:0,
	//	Describe:  vipInfo.Name,
	//	Money:     vipInfo.Money,
	//	CreatedAt: time.Now(),
	//	UpdatedAt: time.Now(),
	//})

	//if rs.Error != nil {
	//	db.Rollback()
	//	appG.ResponseMsg(200, "账单明细记录错误！", "")
	//	return
	//}

	// TODO 企业版本
	// 企业返佣
	eu := db.Table("enterprise_user_commission_details").Create(&models.EnterpriseUserCommissionDetails{
		UserId:     userInfo.ID,
		RelationId: userInfo.EnterpriseUserId,
		Proportion: ENTERPRISE_USER_PROPORTION,
		Money:      vipInfo.Money * ENTERPRISE_USER_PROPORTION,
		Status:     0,
		CreatedAt:  time.Now(),
		UpdatedAt:  time.Now(),
	})

	if eu.Error != nil {
		db.Rollback()
		appG.ResponseMsg(200, "企业返佣记录错误！", "")
		return
	}

	db.Commit() // 提交事物

	appG.ResponseMsg(200, "充值成功！", "")
}

func distributionExtract(userInfo *models.Users, db *gorm.DB, money float64, OutTradeNo string) string {
	//TODO @1 如果该用户是业务员
	if userInfo.Type == 3 {
		// 运营和城市管理中心提成
		e := oprator_and_place_partner(userInfo, db, money, OutTradeNo)
		if e != "" {
			return e
		}
	}

	//TODO @2 如果该用户是会员
	if userInfo.Type == 4 {

		user := models.Users{
			ID: userInfo.Pid,
		}
		parentInfo, _ := user.GetUserInfoById() // 用户上级信息

		if parentInfo != nil {
			/**
			* $1 开始
			* $1 种情况是上级是业务员，应该给一级业务员，运营，城市提成
			*/
			if parentInfo.Type == 3 {
				r := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
					UserId:     userInfo.ID,
					RelationId: userInfo.Pid, // 业务员
					Relation:   3,
					Proportion: ONE_SALESMAN_PROPORTION,         // 分销比例
					Money:      money * ONE_SALESMAN_PROPORTION, // 分销提成
					Status:     0,
					OutTradeNo: OutTradeNo,
					CreatedAt:  time.Now(),
					UpdatedAt:  time.Now(),
				})
				if r.Error != nil {
					return "一级业务员提成错误！"
				}
				// 运营和城市管理中心提成
				e := oprator_and_place_partner(userInfo, db, money, OutTradeNo)
				if e != "" {
					return e
				}
			}
			/**
			 * $1 种情况是上级是业务员，应该给一级业务员，运营，城市提成
			 * $1 结束
			 */

			/**
			* $2 开始
			* $2.1种情况是上级是会员，会员上级是业务员，应该给一级会员，二级业务员，运营，城市提成
			* $2.2种情况是上级是会员，会员也是会员，应该给二级会员，三级业务员，运营，城市提成
			*/

			if parentInfo.Type == 4 {
				r := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
					UserId:     userInfo.ID,
					RelationId: userInfo.Pid, // 一级普通会员
					Relation:   1,
					Proportion: ONE_USER_PROPORTION,         // 分销比例
					Money:      money * ONE_USER_PROPORTION, // 分销提成
					Status:     0,
					OutTradeNo: OutTradeNo,
					CreatedAt:  time.Now(),
					UpdatedAt:  time.Now(),
				})
				if r.Error != nil {
					return "一级普通会员提成错误！"
				}

				user := models.Users{
					ID: parentInfo.Pid,
				}
				parentParentInfo, _ := user.GetUserInfoById() // 用户上上级信息

				// 二级业务员提成
				if parentParentInfo != nil {
					// 如果是业务员（2.1种情况是上级是会员，会员上级是业务员，应该给一级会员，二级业务员，运营，城市提成）
					if parentParentInfo.Type == 3 {
						r := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
							UserId:     userInfo.ID,
							RelationId: userInfo.SalesmanId, // 二级业务员
							Relation:   4,
							Proportion: TWO_SALESMAN_PROPORTION,         // 分销比例
							Money:      money * TWO_SALESMAN_PROPORTION, // 分销提成
							Status:     0,
							OutTradeNo: OutTradeNo,
							CreatedAt:  time.Now(),
							UpdatedAt:  time.Now(),
						})
						if r.Error != nil {
							return "二级业务员提成错误！"
						}
					}
					// 如果是会员(2.2种情况是上级是会员，会员也是会员，应该给二级会员，三级业务员，运营，城市提成)
					if parentParentInfo.Type == 4 {
						r := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
							UserId:     userInfo.ID,
							RelationId: parentParentInfo.ID, // 二级普通会员
							Relation:   2,
							Proportion: TWO_USER_PROPORTION,         // 分销比例
							Money:      money * TWO_USER_PROPORTION, // 分销提成
							Status:     0,
							OutTradeNo: OutTradeNo,
							CreatedAt:  time.Now(),
							UpdatedAt:  time.Now(),
						})

						if r.Error != nil {
							return "二级普通会员错误！"
						}

						rs := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
							UserId:     userInfo.ID,
							RelationId: userInfo.SalesmanId, // 三级等以上业务
							Relation:   5,
							Proportion: THREE_SALESMAN_PROPORTION,         // 分销比例
							Money:      money * THREE_SALESMAN_PROPORTION, // 分销提成
							Status:     0,
							OutTradeNo: "",
							CreatedAt:  time.Now(),
							UpdatedAt:  time.Now(),
						})

						if rs.Error != nil {
							return "三级等以上业务员错误！"
						}
					}
				}
				// 运营和城市管理提成
				e := oprator_and_place_partner(userInfo, db, money, OutTradeNo)
				if e != "" {
					return e
				}

			}

			/**
			 * $2.1种情况是上级是会员，会员上级是业务员，应该给一级会员，二级业务员，运营，城市提成
			 * $2.2种情况是上级是会员，会员也是会员，应该给二级会员，三级业务员，运营，城市提成
			 * $2 结束
			 */
		}
	}
	return ""
}

func oprator_and_place_partner(userInfo *models.Users, db *gorm.DB, money float64, OutTradeNo string) string {
	// 运营提成
	if userInfo.OperatorId > 0 {
		r := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
			UserId:     userInfo.ID,
			RelationId: userInfo.OperatorId,
			Relation:   6,
			Proportion: OPRATOR_PROPORTION,         // 分销比例
			Money:      money * OPRATOR_PROPORTION, // 分销提成
			Status:     0,
			OutTradeNo: OutTradeNo,
			CreatedAt:  time.Now(),
			UpdatedAt:  time.Now(),
		})
		if r.Error != nil {
			return "运营提成错误！"
		}

	} else {
		// 记录错误日志
		r := db.Table("distribution_reward_error_log").Create(&models.DistributionRewardErrorLog{
			ErrorId: userInfo.ID,
			Message: "本身是业务员但是没有运营商记录，请查询一下数据库",
		})
		if r.Error != nil {
			return "本身是业务员但是没有运营商记录！"
		}
	}
	//城市管理提成
	if userInfo.PlacePartnerId > 0 {
		r := db.Table("user_commission_details").Create(&models.UserCommissionDetails{
			UserId:     userInfo.ID,
			RelationId: userInfo.PlacePartnerId,
			Relation:   7,
			Proportion: PLACE_PARTNER_PROPORTION,         // 分销比例
			Money:      money * PLACE_PARTNER_PROPORTION, // 分销提成
			Status:     0,
			OutTradeNo: OutTradeNo,
			CreatedAt:  time.Now(),
			UpdatedAt:  time.Now(),
		})
		if r.Error != nil {
			return "城市管理提成错误！"
		}

	} else {
		// 记录错误日志
		r := db.Table("distribution_reward_error_log").Create(&models.DistributionRewardErrorLog{
			ErrorId: userInfo.ID,
			Message: "本身是业务员但是没有城市合伙人记录，请查询一下数据库",
		})
		if r.Error != nil {
			return "本身是业务员但是没有城市合伙人记录！"
		}
	}
	return ""
}
